{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-02-13T09:13:07.915032Z",
     "start_time": "2025-02-13T09:13:07.868547Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-14T03:15:17.419957Z",
     "start_time": "2025-02-14T03:15:17.380535Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\n",
    "        \"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "cutword()"
   ],
   "id": "42d586ffb5a4969c",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "('今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。',\n",
       " '我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。',\n",
       " '如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-14T03:25:22.443552Z",
     "start_time": "2025-02-14T03:25:22.435271Z"
    }
   },
   "cell_type": "code",
   "source": [
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()  #jieba分词好的中文文本\n",
    "    print('-' * 50)\n",
    "    # print(c1)  #把分词好的文本打印出来\n",
    "    # print(c2)\n",
    "    # print(c3)\n",
    "    print('$' * 50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "    print('$'*60)\n",
    "    print(data.data)\n",
    "    print(len(data.data))\n",
    "    print(data.shape)\n",
    "    # print(cv.get_feature_names_out())  #把处理好后的特征名称打印出来\n",
    "    print(data)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# cutword()\n",
    "hanzivec()"
   ],
   "id": "7f3408c9c65ff384",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n",
      "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n",
      "[2 2 2 1 1 1 1 1 1 1 1 1 3 2 1 1 1 1 1 1 1 1 1 1 1 1 1 4 1 3 1 2 1 1 1 1 1]\n",
      "37\n",
      "(3, 36)\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 37 stored elements and shape (3, 36)>\n",
      "  Coords\tValues\n",
      "  (0, 6)\t2\n",
      "  (0, 26)\t2\n",
      "  (0, 22)\t2\n",
      "  (0, 12)\t1\n",
      "  (0, 32)\t1\n",
      "  (0, 31)\t1\n",
      "  (0, 14)\t1\n",
      "  (0, 24)\t1\n",
      "  (0, 19)\t1\n",
      "  (0, 27)\t1\n",
      "  (0, 2)\t1\n",
      "  (0, 20)\t1\n",
      "  (1, 18)\t3\n",
      "  (1, 28)\t2\n",
      "  (1, 23)\t1\n",
      "  (1, 7)\t1\n",
      "  (1, 8)\t1\n",
      "  (1, 3)\t1\n",
      "  (1, 9)\t1\n",
      "  (1, 35)\t1\n",
      "  (1, 17)\t1\n",
      "  (1, 34)\t1\n",
      "  (2, 18)\t1\n",
      "  (2, 16)\t1\n",
      "  (2, 11)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 21)\t1\n",
      "  (2, 4)\t4\n",
      "  (2, 25)\t1\n",
      "  (2, 5)\t3\n",
      "  (2, 1)\t1\n",
      "  (2, 29)\t2\n",
      "  (2, 13)\t1\n",
      "  (2, 30)\t1\n",
      "  (2, 10)\t1\n",
      "  (2, 15)\t1\n",
      "  (2, 33)\t1\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 34
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# tf-idf",
   "id": "ffee0bf19c4e107e"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-14T03:29:49.895175Z",
     "start_time": "2025-02-14T03:29:49.887040Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 规范{'l1'，'l2'}，默认='l2'\n",
    "# 每个输出行都有单位范数，或者：\n",
    "#\n",
    "# 'l2'：向量元素的平方和为 1。当应用 l2 范数时，两个向量之间的余弦相似度是它们的点积。\n",
    "#\n",
    "# 'l1'：向量元素的绝对值之和为 1。参见preprocessing.normalize。\n",
    "\n",
    "# smooth_idf布尔值，默认 = True\n",
    "# 通过在文档频率上加一来平滑 idf 权重，就好像看到一个额外的文档包含集合中的每个术语恰好一次。防止零分裂。\n",
    "# 比如训练集中有某个词，测试集中没有，就是生僻词，就会造成n(x)分母为零，log(n/n(x)),从而出现零分裂\n",
    "\n",
    "def tfidfvec():\n",
    "    \"\"\"\n",
    "    中文特征值化,计算tfidf值\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()\n",
    "\n",
    "    print(c1, c2, c3)\n",
    "    # print(type([c1, c2, c3]))\n",
    "    tf = TfidfVectorizer(smooth_idf=True)\n",
    "\n",
    "    data = tf.fit_transform([c1, c2, c3])\n",
    "    print(tf.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(type(data))\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "    print('$'*90)\n",
    "    print(data)\n",
    "    return None\n",
    "\n",
    "\n",
    "tfidfvec()"
   ],
   "id": "e94e5fce4eda9b54",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。 我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。 如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[0.         0.         0.21821789 0.         0.         0.\n",
      "  0.43643578 0.         0.         0.         0.         0.\n",
      "  0.21821789 0.         0.21821789 0.         0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.43643578 0.\n",
      "  0.21821789 0.         0.43643578 0.21821789 0.         0.\n",
      "  0.         0.21821789 0.21821789 0.         0.         0.        ]\n",
      " [0.         0.         0.         0.2410822  0.         0.\n",
      "  0.         0.2410822  0.2410822  0.2410822  0.         0.\n",
      "  0.         0.         0.         0.         0.         0.2410822\n",
      "  0.55004769 0.         0.         0.         0.         0.2410822\n",
      "  0.         0.         0.         0.         0.48216441 0.\n",
      "  0.         0.         0.         0.         0.2410822  0.2410822 ]\n",
      " [0.15698297 0.15698297 0.         0.         0.62793188 0.47094891\n",
      "  0.         0.         0.         0.         0.15698297 0.15698297\n",
      "  0.         0.15698297 0.         0.15698297 0.15698297 0.\n",
      "  0.1193896  0.         0.         0.15698297 0.         0.\n",
      "  0.         0.15698297 0.         0.         0.         0.31396594\n",
      "  0.15698297 0.         0.         0.15698297 0.         0.        ]]\n",
      "$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n",
      "<Compressed Sparse Row sparse matrix of dtype 'float64'\n",
      "\twith 37 stored elements and shape (3, 36)>\n",
      "  Coords\tValues\n",
      "  (0, 6)\t0.43643578047198467\n",
      "  (0, 26)\t0.43643578047198467\n",
      "  (0, 22)\t0.43643578047198467\n",
      "  (0, 12)\t0.21821789023599233\n",
      "  (0, 32)\t0.21821789023599233\n",
      "  (0, 31)\t0.21821789023599233\n",
      "  (0, 14)\t0.21821789023599233\n",
      "  (0, 24)\t0.21821789023599233\n",
      "  (0, 19)\t0.21821789023599233\n",
      "  (0, 27)\t0.21821789023599233\n",
      "  (0, 2)\t0.21821789023599233\n",
      "  (0, 20)\t0.21821789023599233\n",
      "  (1, 18)\t0.5500476874707073\n",
      "  (1, 28)\t0.482164405401355\n",
      "  (1, 23)\t0.2410822027006775\n",
      "  (1, 7)\t0.2410822027006775\n",
      "  (1, 8)\t0.2410822027006775\n",
      "  (1, 3)\t0.2410822027006775\n",
      "  (1, 9)\t0.2410822027006775\n",
      "  (1, 35)\t0.2410822027006775\n",
      "  (1, 17)\t0.2410822027006775\n",
      "  (1, 34)\t0.2410822027006775\n",
      "  (2, 18)\t0.11938959557761185\n",
      "  (2, 16)\t0.15698297076974738\n",
      "  (2, 11)\t0.15698297076974738\n",
      "  (2, 0)\t0.15698297076974738\n",
      "  (2, 21)\t0.15698297076974738\n",
      "  (2, 4)\t0.6279318830789895\n",
      "  (2, 25)\t0.15698297076974738\n",
      "  (2, 5)\t0.47094891230924213\n",
      "  (2, 1)\t0.15698297076974738\n",
      "  (2, 29)\t0.31396594153949475\n",
      "  (2, 13)\t0.15698297076974738\n",
      "  (2, 30)\t0.15698297076974738\n",
      "  (2, 10)\t0.15698297076974738\n",
      "  (2, 15)\t0.15698297076974738\n",
      "  (2, 33)\t0.15698297076974738\n"
     ]
    }
   ],
   "execution_count": 39
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 2 特征处理，不同的特征拉到到同一个量纲",
   "id": "f8c7a7106fc35e66"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-14T03:49:34.322351Z",
     "start_time": "2025-02-14T03:49:34.308999Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: NOne\n",
    "    \"\"\"\n",
    "    # 归一化缺点 容易受极值的影响\n",
    "    #feature_range代表特征值范围，一般设置为(0,1),或者(-1,1),默认是(0,1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    out = mm.transform([[1, 2, 3, 4], [6, 5, 8, 7]])\n",
    "    print(out)\n",
    "    return None\n",
    "    #transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值\n",
    "\n",
    "\n",
    "mm()"
   ],
   "id": "c7537b182709095a",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 40
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-14T03:50:04.562317Z",
     "start_time": "2025-02-14T03:50:04.553496Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.],\n",
    "                              [2., 4., 2.],\n",
    "                              [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)  #方差\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data = stand()"
   ],
   "id": "97681054154dd0bf",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 41
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-14T03:50:28.954544Z",
     "start_time": "2025-02-14T03:50:28.948868Z"
    }
   },
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform([[-1.06904497, -1.35873244, 0.98058068],\n",
    "                            [-0.26726124, 0.33968311, 0.39223227],\n",
    "                            [1.33630621, 1.01904933, -1.37281295]])\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "id": "5576715be3eb070b",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0.]\n",
      "[1.         1.         1.00000001]\n"
     ]
    }
   ],
   "execution_count": 42
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## transform和fit_transform不同是，transform用于测试集，而且不会重新找最小值和最大值,不会重新计算均值方差",
   "id": "6bb5c9977581bddb"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 3 缺失值处理\n",
   "id": "ab788c0cbf179da6"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-14T03:51:44.280886Z",
     "start_time": "2025-02-14T03:51:44.269081Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#下面是填补，针对删除，可以用pd和np\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return:None\n",
    "    \"\"\"\n",
    "    # NaN, nan,缺失值必须是这种形式，如果是？号(或者其他符号)，就要replace换成这种\n",
    "    #mean, median, most_frequent(众数), constant\n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')\n",
    "\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "im()"
   ],
   "id": "10dd5cf3ed45b2a6",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 43
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 4 降维\n",
    "# 降维就是特征数变少\n",
    "# 降维可以提高模型训练速度（特征变少）"
   ],
   "id": "e8dec5a0a2e50d0a"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-14T03:52:36.454383Z",
     "start_time": "2025-02-14T03:52:36.446474Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()\n"
   ],
   "id": "eb5bb61c948e3249",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "--------------------------------------------------\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 44
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-14T03:56:48.828055Z",
     "start_time": "2025-02-14T03:56:48.821987Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5],\n",
    "                               [6, 3, 0, 8],\n",
    "                               [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0))\n",
    "    print(np.var(original_value, axis=0).sum())  #最初数据每一列的方差，求和\n",
    "    print('-' * 50)\n",
    "    pca = PCA(n_components=0.9)\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差和\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-' * 50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "id": "ec2b1d0173ed349a",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2.88888889  4.66666667 13.55555556  8.22222222]\n",
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 52
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-02-14T06:02:04.934265Z",
     "start_time": "2025-02-14T06:02:03.148530Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "x = np.random.rand(10000)  #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t, x, 'g.', label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "id": "79d06b0ea97cd0a2",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 53
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
